/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package agen.util;

/**
 *
 * @author juan
 */
public class Arreglos {

// <editor-fold defaultstate="collapsed" desc="Codigo robado de la clase java.util.Arrays">
    /*
     * Este fragmento de codigo lo modifique para que al ordenar un double[]
     * poder generar una relacion entre las nuevas posiciones de las aptitudes
     * con los individuos a los que cada aptitud le corresponde.
     * Me salteo la fase 2 y 3 confiando en que no hay NaNs ni -0.0.
     * Se consigue mediante un int[double.length] ordenado de 0 a n que se ordena
     * de la misma forma que double[]. Asi cada elemento de este int[] señala
     * de que ubicacion vino.
     */
    public static int recurLevel = 0;
    /**
     * Sorts the specified sub-array of doubles into ascending order.
     */
    public static void sort1(double x[], int[] posision, int off, int len) {
        /*Inicialmente cada elto debe tener su indice como valor*/

        if (recurLevel++ == 0){
            for (int i = posision.length - 1; i >= 0; i--) {
                posision[i] = i;
            }
        }
        // Insertion sort on smallest arrays
        if (len < 7) {
            for (int i = off; i < len + off; i++) {
                for (int j = i; j > off && x[j - 1] > x[j]; j--) {
                    swap(x, posision, j, j - 1);
                }
            }
            recurLevel--;
            return;

        }

        // Choose a partition element, v

        int m = off + (len >> 1);       // Small arrays, middle element
        if (len > 7) {
            int l = off;
            int n = off + len - 1;
            if (len > 40) {        // Big arrays, pseudomedian of 9
                int s = len / 8;
                l =
                        med3(x, l, l + s, l + 2 * s);
                m =
                        med3(x, m - s, m, m + s);
                n =
                        med3(x, n - 2 * s, n - s, n);
            }

            m = med3(x, l, m, n); // Mid-size, med of 3
        }

        double v = x[m];

        // Establish Invariant: v* (<v)* (>v)* v*
        int a = off, b = a, c = off + len - 1, d = c;
        while (true) {
            while (b <= c && x[b] <= v) {
                if (x[b] == v) {
                    swap(x, posision, a++, b);
                }
                b++;

            }


            while (c >= b && x[c] >= v) {
                if (x[c] == v) {
                    swap(x, posision, c, d--);
                }
                c--;

            }


            if (b > c) {
                break;
            }
            swap(x, posision, b++, c--);
        }

// Swap partition elements back to middle
        int s, n = off + len;
        s =
                Math.min(a - off, b - a);
        vecswap(x, posision, off, b - s, s);
        s =
                Math.min(d - c, n - d - 1);
        vecswap(x, posision, b, n - s, s);

        // Recursively sort non-partition-elements
        if ((s = b - a) > 1) {
            sort1(x, posision, off, s);
        }
        if ((s = d - c) > 1) {
            sort1(x, posision, n - s, s);
        }
        recurLevel--;
    }

    /**
     * Swaps x[a] with x[b].
     */
    private static void swap(double x[], int[] posision, int a, int b) {
        double t = x[a];
        x[a] = x[b];
        x[b] = t;
        int p = posision[a];
        posision[a] = posision[b];
        posision[b] = p;
    }

    /**
     * Swaps x[a .. (a+n-1)] with x[b .. (b+n-1)].
     */
    private static void vecswap(double x[], int[] posision, int a, int b, int n) {
        for (int i = 0; i < n;
                i++, a++, b++) {
            swap(x, posision, a, b);
        }
    }

    /**
     * Returns the index of the median of the three indexed doubles.
     */
    private static int med3(double x[], int a, int b, int c) {
        return (x[a] < x[b] ? (x[b] < x[c] ? b : x[a] < x[c] ? c : a) : (x[b] > x[c] ? b : x[a] > x[c] ? c : a));
    }
//</editor-fold>
}
